home *** CD-ROM | disk | FTP | other *** search
/ Aminet 22 / Aminet 22 (1997)(GTI - Schatztruhe)[!][Dec 1997].iso / Aminet / dev / src / ConfigFileSrc.lha / ConfigFileSrc12 / Library / Funcs / StrConv.asm < prev    next >
Encoding:
Assembly Source File  |  1997-10-02  |  7.3 KB  |  530 lines
  1. *
  2. *  $PROJECT: ConfigFile.library
  3. *  $FILE: StrConv.asm
  4. *  $DESCRIPTION:  String converting functions.
  5. *
  6. *  (C) Copyright 1997 Marcel Karas
  7. *      All Rights Reserved.
  8. *
  9.  
  10.     SECTION    text,CODE
  11.  
  12. _MC68020        EQU    1
  13.  
  14.     XREF    _CType
  15.  
  16. CTB_LOWER    EQU    0
  17. CTB_HEX        EQU    7
  18.  
  19. *--------------------------------------------------------------------------*
  20.  
  21. * LongToDecStr -- converting a long to a decimal string
  22. *
  23. * A0  - Pointer to the storage string
  24. * D0  - Long
  25. * >A0 - New pointer
  26. *
  27.     XDEF    _LongToDecStr
  28. _LongToDecStr:
  29.  
  30.     BTST        #31,D0
  31.     BEQ.B        NoSign
  32.     NEG.L        D0
  33.     MOVE.B    #'-',(A0)+
  34. NoSign:
  35.  
  36. * LongToUnDecStr -- converting a long to a unsigned decimal string
  37. *
  38. * A0  - Pointer to the storage string
  39. * D0  - Long
  40. * >A0 - New pointer
  41. *
  42.  
  43. *    XDEF    _LongToUnDecStr
  44. *_LongToUnDecStr:
  45.  
  46.     IFD        _MC68020
  47.  
  48.     EXG        D2,A1
  49.     BCLR        #1,D2
  50.     BSR.B        ConvDec
  51.     BTST        #1,D2
  52.     BNE.B        ConvDecEnd
  53.     MOVE.B    #'0',(A0)+
  54.  
  55. ConvDecEnd:
  56.     EXG        D2,A1
  57. *    MOVE.B    #0,(A0)
  58.     MOVE.L    A0,D0
  59.     RTS
  60.  
  61. ConvDec:
  62.  
  63.     CMP.L        #$FF,D0
  64.     BLS.S        TinyConv
  65.  
  66.     CMP.L        #$FFFF,D0
  67.     BLS.B        SmallConv
  68.  
  69.     DIVUL.L    #1000000000,D1:D0
  70.     BSR.B        ConvDigit
  71.  
  72.     DIVUL.L    #100000000,D1:D0
  73.     BSR.B        ConvDigit
  74.  
  75.     DIVUL.L    #10000000,D1:D0
  76.     BSR.B        ConvDigit
  77.  
  78.     DIVUL.L    #1000000,D1:D0
  79.     BSR.B        ConvDigit
  80.  
  81.     DIVUL.L    #100000,D1:D0
  82.     BSR.B        ConvDigit
  83.  
  84. SmallConv:
  85.     DIVUL.L    #10000,D1:D0
  86.     BSR.B        ConvDigit
  87.  
  88.     DIVUL.L    #1000,D1:D0
  89.     BSR.B        ConvDigit
  90.  
  91. TinyConv:
  92.     DIVUL.L    #100,D1:D0
  93.     BSR.B        ConvDigit
  94.  
  95.     DIVUL.L    #10,D1:D0
  96.     BSR        ConvDigit
  97.  
  98. ConvDigit:
  99.     TST.B        D0
  100.     BNE.B        DecNoNull
  101.     BTST        #1,D2
  102.     BEQ.B        DecNoNull2
  103.  
  104. DecNoNull:
  105.     ADD.L        #$30,D0
  106.     MOVE.B    D0,(A0)+
  107.     BSET        #1,D2
  108. DecNoNull2:
  109.     MOVE.L    D1,D0
  110.     RTS
  111.  
  112.     ELSE
  113.  
  114.     MOVEM.L    D2/D3/D4,-(SP)
  115.     BCLR        #1,D4
  116.     BSR.B        ConvDec
  117.     BTST        #1,D4
  118.     BNE.B        ConvDecEnd
  119.     MOVE.B    #'0',(A0)+
  120.  
  121. ConvDecEnd:
  122.     MOVEM.L    (SP)+,D2/D3/D4
  123. *    MOVE.B    #0,(A0)
  124.     MOVE.L    A0,D0
  125.     RTS
  126.  
  127. ConvDec:
  128.  
  129.     CMP.L        #$FF,D0
  130.     BLS.S        TinyConv
  131.  
  132.     CMP.L        #$FFFF,D0
  133.     BLS.S        SmallConv
  134.  
  135.     MOVE.L    #1000000000,D1
  136.     BSR.B        UDivMod32Full
  137.     BSR.B        ConvDigit
  138.  
  139.     MOVE.L    #100000000,D1
  140.     BSR.B        UDivMod32Full
  141.     BSR.B        ConvDigit
  142.  
  143.     MOVE.L    #10000000,D1
  144.     BSR.B        UDivMod32Full
  145.     BSR.B        ConvDigit
  146.  
  147.     MOVE.L    #1000000,D1
  148.     BSR.B        UDivMod32Full
  149.     BSR.B        ConvDigit
  150.  
  151.     MOVE.L    #100000,D1
  152.     BSR.B        UDivMod32Full
  153.     BSR.B        ConvDigit
  154.  
  155. SmallConv:
  156.     MOVE.L    #10000,D1
  157.     BSR.B        UDivMod32Small
  158.     BSR.B        ConvDigit
  159.  
  160.     MOVE.L    #1000,D1
  161.     BSR.B        UDivMod32Small
  162.     BSR.B        ConvDigit
  163.  
  164. TinyConv:
  165.     MOVE.L    #100,D1
  166.     BSR.B        UDivMod32Small
  167.     BSR.B        ConvDigit
  168.  
  169.     MOVE.L    #10,D1
  170.     BSR.B        UDivMod32Small
  171.     BSR        ConvDigit
  172.  
  173. ConvDigit:
  174.     TST.B        D0
  175.     BNE.B        DecNoNull
  176.     BTST        #1,D4
  177.     BEQ.B        DecNoNull2
  178.  
  179. DecNoNull:
  180.     ADD.L        #$30,D0
  181.     MOVE.B    D0,(A0)+
  182.     BSET        #1,D4
  183. DecNoNull2:
  184.     MOVE.L    D1,D0
  185.     RTS
  186.  
  187. UDivMod32Full:
  188.     MOVE.L    D1,D3
  189.     MOVE.L    D0,D1
  190.     CLR.W        D1
  191.     SWAP        D0
  192.     SWAP        D1
  193.     CLR.W        D0
  194.     MOVEQ        #$F,D2
  195. .Loop:
  196.     ADD.L        D0,D0
  197.     ADDX.L    D1,D1
  198.     CMP.L        D1,D3
  199.     BHI.B        .LoopEnd
  200.     SUB.L        D3,D1
  201.     ADDQ.W    #1,D0
  202. .LoopEnd:
  203.     DBRA        D2,.Loop
  204.     RTS
  205.  
  206. UDivMod32Small:
  207.     MOVE.L    D1,D3
  208.     SWAP        D0
  209.     MOVE.W    D0,D3
  210.     BEQ.B        SmallDiv
  211.     DIVU        D1,D3
  212.     MOVE.W    D3,D0
  213. SmallDiv:
  214.     SWAP        D0
  215.     MOVE.W    D0,D3
  216.     DIVU        D1,D3
  217.     MOVE.W    D3,D0
  218.     SWAP        D3
  219.     MOVE.W    D3,D1
  220.     RTS
  221.  
  222.     ENDC
  223.  
  224. *--------------------------------------------------------------------------*
  225.  
  226. * LongToHexStr -- converting a long to a hexa decimal string
  227. *
  228. * A0  - Pointer to the storage string
  229. * D0  - Long
  230. * >A0 - New pointer
  231. *
  232.     XDEF    _LongToHexStr
  233. _LongToHexStr:
  234.  
  235.     MOVE.L    D2,-(SP)
  236.     MOVEQ        #7,D2
  237.     CLR.L        D1
  238.     LEA        HexArry(PC),A1
  239.     MOVE.B    #'$',(A0)+
  240.  
  241.     CMP.L        #$FFFF,D0
  242.     BHI.B        HexInLoop
  243.     MOVEQ        #3,D1
  244.  
  245.     CMP.L        #$FF,D0
  246.     BHI.B        HexInLoop
  247.     MOVEQ        #1,D1
  248.  
  249. HexInLoop:
  250.     ROL.L        #4,D0
  251.     MOVE.B    D0,D1
  252.     AND        #$0F,D1
  253.     TST.B        D1
  254.     BNE.B        NoNull
  255.     BTST        #31,D1
  256.     BEQ.B        NoNull2
  257.  
  258. NoNull:
  259.     MOVE.B    0(A1,D1),D1
  260.     MOVE.B    D1,(A0)+
  261.     BSET        #31,D1
  262. NoNull2:
  263.     DBRA        D2,HexInLoop
  264.  
  265.     BTST        #31,D1
  266.     BNE.B        HexConvEnd
  267.     MOVE.B    #'0',(A0)+
  268.  
  269. HexConvEnd:
  270.  
  271.     MOVE.L    (SP)+,D2
  272. *    MOVE.B    #0,(A0)
  273.     MOVE.L    A0,D0
  274.     RTS
  275.  
  276. HexArry:
  277.     DC.B        '0123456789ABCDEF'
  278.  
  279. *--------------------------------------------------------------------------*
  280.  
  281. * LongToBinStr -- converting a long to a binary string
  282. *
  283. * A0  - Pointer to the storage string
  284. * D0  - Long
  285. * >A0 - New pointer
  286. *
  287.     XDEF    _LongToBinStr
  288. _LongToBinStr:
  289.  
  290.     MOVE.B    #'%',(A0)+
  291.     MOVEQ        #31,D1
  292.  
  293.     CMP.L        #$FFFF,D0
  294.     BHI.B        BitInLoop
  295.     MOVEQ        #15,D1
  296.  
  297.     CMP.L        #$FF,D0
  298.     BHI.B        BitInLoop
  299.     MOVEQ        #7,D1
  300.  
  301. BitInLoop:
  302.     BTST        D1,D0
  303.     BEQ.B        BitIsNull
  304.  
  305.     MOVE.B    #'1',(A0)+
  306.     BSET        #31,D0
  307.     BRA.B        LastBitCheck
  308.  
  309. BitIsNull:
  310.     BTST        #31,D0
  311.     BEQ.B        LastBitCheck
  312.     MOVE.B    #'0',(A0)+
  313.  
  314. LastBitCheck:
  315.     DBF        D1,BitInLoop
  316.  
  317.     BTST        #31,D0
  318.     BNE.B        BinConvEnd
  319.     MOVE.B    #'0',(A0)+
  320.  
  321. BinConvEnd:
  322. *    MOVE.B    #0,(A0)
  323.     MOVE.L    A0,D0
  324.     RTS
  325.  
  326. *--------------------------------------------------------------------------*
  327.  
  328. * LongToOctStr -- converting a long to a octal string
  329.  
  330. *--------------------------------------------------------------------------*
  331.  
  332. * DecStrToLong -- converting a decimal string to a long
  333. *
  334. * A0  - Pointer to the hex string
  335. * A1  - Storage pointer for the Long
  336. * >A1 - Store Long
  337. * >A0 - New pointer
  338. *
  339.  
  340.     XDEF    _DecStrToLong
  341. _DecStrToLong:
  342.     IFD        _MC68020
  343.  
  344.     MOVE.L    D2,-(SP)
  345.     CLR.L        D0
  346.     CLR.L        D1
  347.     MOVE.B    (A0),D2
  348.     CMPI.B    #'-',D2
  349.     BNE.B        DecConv
  350.     ADDQ        #1,A0
  351.  
  352. DecConv:
  353.     MOVE.B    (A0)+,D0
  354.     SUBI.B    #'0',D0
  355.  
  356. DecInLoop:
  357.     CLR.B        D1
  358.     MOVE.B    (A0)+,D1
  359.     SUBI.B    #'0',D1
  360.  
  361.     CMPI.B    #10,D1
  362.     BCC.B        DecInOk
  363.     MULU.L    #10,D0
  364.     ADD.L        D1,D0
  365.     BRA.B        DecInLoop
  366.  
  367. DecInOk:
  368.     SUBQ        #1,A0
  369.     CMPI.B    #'-',D2
  370.     BNE.B        DecEnd
  371.     NEG.L        D0
  372.  
  373. DecEnd:
  374.  
  375.     MOVE.L    (SP)+,D2
  376.     MOVE.L    D0,(A1)
  377.     MOVE.L    A0,D0
  378.     RTS
  379.  
  380.     ELSE
  381.  
  382.     CLR.L        D0
  383.     MOVEM.L    D2/D3/D4/D5,-(SP)
  384.  
  385.     MOVE.B    (A0),D4
  386.     CMPI.B    #'-',D4
  387.     BNE.B        DecConv
  388.     ADDQ        #1,A0
  389.  
  390. DecConv:
  391.     MOVE.B    (A0)+,D0
  392.     SUBI.W    #'0',D0
  393.  
  394. DecInLoop:
  395.     CLR.L        D1
  396.     MOVE.B    (A0)+,D1
  397.     SUBI.W    #'0',D1
  398.  
  399.     CMPI.W    #10,D1
  400.     BCC.B        DecInOk
  401.  
  402. ** UMult32 **
  403.     MOVE.L    #10,D5
  404.     CLR.L        D2
  405.     CLR.L        D3
  406.  
  407.     ** ad **
  408.     MOVE.W    D5,D3
  409.     SWAP.W    D0
  410.     MULU.W    D0,D3
  411.  
  412.     ** bc **
  413.     SWAP.W    D0
  414.     MOVE.W    D0,D2
  415.     SWAP.W    D5
  416.     MULU.W    D5,D2
  417.  
  418.     ** (ad + bc)^16 **
  419.     ADD.L        D3,D2
  420.     SWAP.W    D2
  421.     CLR.W        D2
  422.  
  423.     ** bd + (ad + bc)^16 **
  424.     SWAP.W    D5
  425.     MULU.W    D5,D0
  426.     ADD.L        D2,D0
  427. ** UMult32 **
  428.  
  429.     ADD.L        D1,D0
  430.     BRA.B        DecInLoop
  431.  
  432. DecInOk:
  433.     SUBQ        #1,A0
  434.     CMPI.B    #'-',D4
  435.     BNE.B        DecEnd
  436.     NEG.L        D0
  437. DecEnd:
  438.     MOVEM.L    (SP)+,D2/D3/D4/D5
  439.     MOVE.L    D0,(A1)
  440.     MOVE.L    A0,D0
  441.     RTS
  442.  
  443.     ENDC
  444. *--------------------------------------------------------------------------*
  445.  
  446. * HexStrToLong -- converting a hexadecimal string to a long
  447. *
  448. * A0  - Pointer to the hex string
  449. * A1  - Storage pointer for the Long
  450. * >A1 - Store Long
  451. * >A0 - New pointer
  452. *
  453.  
  454.     XDEF    _HexStrToLong
  455. _HexStrToLong:
  456.  
  457.     MOVE.L    A1,-(SP)
  458.     MOVEQ        #0,D0
  459.     MOVEQ        #0,D1
  460.     LEA        _CType(A4),A1
  461.  
  462. HexStrLoop:
  463.     ADDQ        #1,A0
  464.     MOVE.B    (A0),D1
  465.     BTST        #CTB_HEX,0(A1,D1)
  466.     BEQ.B        HexStrEnd
  467.  
  468.     BTST        #6,D1
  469.     BEQ.B        IsNum
  470.  
  471.     ANDI.B    #$0F,D1
  472.     ADDI.B    #$09,D1
  473.     LSL.L        #4,D0
  474.     OR.B        D1,D0
  475.     BRA.B        HexStrLoop
  476.  
  477. IsNum:
  478.     ANDI.B    #$0F,D1
  479.     LSL.L        #4,D0
  480.     OR.B        D1,D0
  481.     BRA.B        HexStrLoop
  482.  
  483. HexStrEnd:
  484.  
  485.     MOVE.L    (SP)+,A1
  486.     MOVE.L    D0,(A1)
  487.     MOVE.L    A0,D0
  488.     RTS
  489.  
  490. *--------------------------------------------------------------------------*
  491.  
  492. * BinStrToLong -- converting a binary string to a long
  493. *
  494. * A0  - Pointer to the binary string
  495. * A1  - Storage pointer for the Long
  496. * >A1 - Store Long
  497. * >A0 - New pointer
  498. *
  499.     XDEF    _BinStrToLong
  500. _BinStrToLong:
  501.  
  502.     CLR.L        D0
  503.  
  504. BinStrLoop:
  505.     ADDQ        #1,A0
  506.     CMPI.B    #'1',(A0)
  507.     BNE.B        CharIsNull
  508.     LSL.L        #1,D0
  509.     BSET        #0,D0
  510.     BRA.B        BinStrLoop
  511.  
  512. CharIsNull:
  513.     CMPI.B    #'0',(A0)
  514.     BNE.B        BinStrEnd
  515.     LSL.L        #1,D0
  516.     BRA.B        BinStrLoop
  517.  
  518. BinStrEnd:
  519.     MOVE.L    D0,(A1)
  520.     MOVE.L    A0,D0
  521.     RTS
  522.  
  523. *--------------------------------------------------------------------------*
  524.  
  525. * OctStrToLong -- converting a octal string to a long
  526.  
  527. *--------------------------------------------------------------------------*
  528.  
  529.     END
  530.